/*******************************************************************************
 * 版权：北京润尼尔网络科技有限公司，保留所有版权<br>
 * 版本：v1.0.0<br>
 * 文件：CommandAdd.js<br>
 * 日期：2016年9月20日<br>
 * 作者: 王志远<br>
 * 功能：添加命令<br>
 * 
 * 修改记录：<br>
 * 日期 描述 更新功能<br>
 ******************************************************************************/

window.makeNamespace(window,"Rainier.UI.V2");

/**
 * 类型名称：Rainier.UI.V2.CommandAdd<br>
 * 类型功能：添加元件命令<br>
 */
Rainier.UI.V2.CommandAdd = draw2d.command.Command.extend({
	
	NAME : "Rainier.UI.V2.CommandAdd",
	
	/**
	 * 函数名称：Rainier.UI.V2.CommandAdd.init<br>
	 * 函数功能：构造函数<br>
	 * 异常信息：无<br>
	 */
	init : function(x,y,createInfo,rootEditPart){
		this._super();
		thisx = x;
		thisy = y;
		
		this.x = x;
		this.y = y;
		if(this.x% 9 !== 0){
			this.x = this.x - this.x % 9;
		}
		if(this.y % 9 !== 0){
			this.y = this.y - this.y % 9;
		}
		
		if(thisx% 9 !== 0){
			thisx = thisx - thisx % 9;
		}
		if(thisy % 9 !== 0){
			thisy = thisy - thisy % 9;
		}
		
		this.createInfo   = jQuery.extend(true,{},createInfo);;
		thisrootEditPart = rootEditPart;
		this.createdModel = null;
		this.createdModelArray = [];
		// this.portsArray = {};
		this.ports		  = new draw2d.util.ArrayList();
	},
	
	/**
	 * 函数名称：Rainier.UI.V2.CommandMove.canExecute<br>
	 * 函数功能：能否执行<br>
	 * 函数返回：Boolean<br>
	 * 异常信息：无<br>
	 */
	canExecute:function(){
		if(this.createInfo.modelClass){
			return true;
		}else{    		
			return false;
		}
	},
	
	/**
	 * 函数名称：Rainier.UI.V2.CommandMove.execute<br>
	 * 函数功能：执行命令<br>
	 * 函数返回：无<br>
	 * 异常信息：无<br>
	 */
	execute:function(){
		var _this = this;
		var className = this.createInfo.modelClass;
		var property  = this.createInfo.modelProperty;
		var json	  = this.createInfo.json;
		var createdModelArray = this.createdModelArray;
		if(!json){
			this.createdModel  = eval('new ' + className + "();");
			if(property){
				var dummy = jQuery.extend(true,{},property);
				this.createdModel.property = dummy;
			}    		
		}else{
			var ret = eval(json);
			// if(ret.modelProperty.defaultLabel === "1-"){
			// 	ret.modelProperty.defaultLabel = "1-1-";
			// }
			// if(ret.modelProperty.defaultLabel === "1-1-1-"){
			// 	ret.modelProperty.defaultLabel = "1-1-";
			// }
			//利用恢复实验的方法创建串并行流程框
			// if(ret.experimentInfo&&(ret.experimentInfo.experimentName == "Parallel")){
			// 	//修改流程框位置
			// 	var componentList = ret.experimentScene.componentList;
			// 	var connectionList = ret.experimentScene.connectionList;
			// 	$.each(componentList,function(index,component){
			// 		var createdModel = null;
			// 		var label = component.modelProperty.label;
			// 		var x = 0;
			// 		var y = 0;
			// 		if(label=="First1"){
			// 			createdModel = Rainier.UI.V2.DeviceModelBuilder.buildModel(component);
			// 			x = thisx;
			// 			y = thisy;
			// 		}
			// 		if(label=="Second1"){
			// 			createdModel = Rainier.UI.V2.DeviceModelBuilder.buildModel(component);
			// 			x = thisx+250;
			// 			y = thisy-100;
			// 		}
			// 		if(label=="Second2"){
			// 			createdModel = Rainier.UI.V2.DeviceModelBuilder.buildModel(component);
			// 			x = thisx+250;
			// 			y = thisy;
			// 		}
			// 		if(label=="Second3"){
			// 			createdModel = Rainier.UI.V2.DeviceModelBuilder.buildModel(component);
			// 			x = thisx+250;
			// 			y = thisy+100;
			// 		}
			// 		//创建器件
			// 		if(createdModel){          
			// 		var inputs   = createdModel.getInputPorts();
			// 		var outputs  = createdModel.getOutputPorts();
			// 		var hybrids  = createdModel.getHybridPorts();
			// 		component.ports = [];
			// 		inputs.each(function(i,p){
			// 			component.ports.push(p);
			// 		});
			// 		outputs.each(function(i,p){
			// 			component.ports.push(p);
			// 		});
			// 		hybrids.each(function(i,p){
			// 			component.ports.push(p);
			// 		});
			// 		//存储端口信息
			// 		createdModel.property.modelProperty.ports = component.ports;
			// 		}
			// 		thisrootEditPart.getModel().addChildModel(createdModel);
			// 		createdModel.setPosition(x,y,false);
			// 		createdModelArray.push(createdModel);
			// 		// console.log(createdModelArray);
			// 	});
			// 	//创建连线
			// 	var sPort = null;
			// 	var tPort = null;
			// 	var activeEditor = app.getContext().getActiveEditor();
			// 	$.each(componentList,function(index,component){
			// 		var ports = component.ports;
			// 		var label = component.modelProperty.label;
			// 		if(label=="First1"){
			// 			$.each(ports,function(i,port){
			// 				if(port.property.modelProperty.locator.x==180){
			// 					sPort = port;
			// 				}
			// 			});
			// 		}
			// 		if(label=="Second1"){
			// 			$.each(ports,function(i,port){
			// 				if(port.property.modelProperty.id==1){
			// 					tPort = port;
			// 					if(sPort){
			// 						var segment = connectionList[0].modelProperty.segments;
			// 						segment[1].start_x = thisx+180;
			// 						segment[1].start_y = thisy-73;
			// 						activeEditor.makeConnection(sPort,tPort,connectionList[0]);
			// 					}
			// 				}
			// 			});
			// 		}
			// 		if(label=="Second2"){
			// 			$.each(ports,function(i,port){
			// 				if(port.property.modelProperty.id==1){
			// 					tPort = port;
			// 					if(sPort){
			// 						activeEditor.makeConnection(sPort,tPort,connectionList[1]);
			// 					}
			// 				}
			// 			});
			// 		}
			// 		if(label=="Second3"){
			// 			$.each(ports,function(i,port){
			// 				if(port.property.modelProperty.id==1){
			// 					tPort = port;
			// 					if(sPort){
			// 						var segment = connectionList[2].modelProperty.segments;
			// 						segment[1].start_x = thisx+180;
			// 						segment[1].start_y = thisy+127;
			// 						activeEditor.makeConnection(sPort,tPort,connectionList[2]);
			// 					}
			// 				}
			// 			});
			// 		}
			// 	});
			// 	// 并行流程框的器件在器件展示栏中的添加
			// 	for(var cl=0;cl<componentList.length;cl++){
			// 		var className = componentList[cl].modelProperty.typeName;
			// 		var componentName = componentList[cl].modelProperty.componentName;
			// 		this.parallelAddUsedPart(className,componentName);
			// 		// console.log(data);
			// 	}
			// }
			// else{
			// 	//串行流程框
			// 	if(ret.experimentInfo&&(ret.experimentInfo.experimentName == "Serial")){
			// 		//修改流程框位置
			// 		var componentList = ret.experimentScene.componentList;
			// 		var connectionList = ret.experimentScene.connectionList;
			// 		$.each(componentList,function(index,component){
			// 			var createdModel = null;
			// 			var label = component.modelProperty.label;
			// 			var x = 0;
			// 			var y = 0;
			// 			if(label=="First1"){
			// 				createdModel = Rainier.UI.V2.DeviceModelBuilder.buildModel(component);
			// 				x = thisx;
			// 				y = thisy;
			// 			}
			// 			if(label=="Second1"){
			// 				createdModel = Rainier.UI.V2.DeviceModelBuilder.buildModel(component);
			// 				x = thisx+250;
			// 				y = thisy;
			// 			}
			// 			if(label=="Third1"){
			// 				createdModel = Rainier.UI.V2.DeviceModelBuilder.buildModel(component);
			// 				x = thisx+500;
			// 				y = thisy;
			// 			}
			// 			 //创建器件
			// 			if(createdModel){          
			// 			var inputs   = createdModel.getInputPorts();
			// 			var outputs  = createdModel.getOutputPorts();
			// 			var hybrids  = createdModel.getHybridPorts();
			// 			component.ports = [];
			// 			inputs.each(function(i,p){
			// 				component.ports.push(p);
			// 			});
			// 			outputs.each(function(i,p){
			// 				component.ports.push(p);
			// 			});
			// 			hybrids.each(function(i,p){
			// 				component.ports.push(p);
			// 			});
			// 			//存储端口信息
			// 			createdModel.property.modelProperty.ports = component.ports;
			// 			}
			// 			thisrootEditPart.getModel().addChildModel(createdModel);
			// 			createdModel.setPosition(x,y,false);
			// 			// portsArray.push(component.ports);
			// 			// console.log(portsArray);
			// 			createdModelArray.push(createdModel);
			// 			// console.log(createdModelArray);
			// 		});
			// 		//创建连线
			// 		var sPort = null;
			// 		var tPort = null;
			// 		var activeEditor = app.getContext().getActiveEditor();
			// 		$.each(componentList,function(index,component){
			// 			var ports = component.ports;
			// 			var label = component.modelProperty.label;
			// 			if(label=="First1"){
			// 				$.each(ports,function(i,port){
			// 					if(port.property.modelProperty.locator.x==180){
			// 						sPort = port;
			// 					}
			// 				});
			// 			}
			// 			if(label=="Second1"){
			// 				$.each(ports,function(i,port){
			// 					if(port.property.modelProperty.locator.x==0){
			// 						tPort = port;
			// 						if(sPort){
			// 							activeEditor.makeConnection(sPort,tPort,connectionList[0]);
			// 						}
			// 					}
			// 				});
			// 				$.each(ports,function(i,port){
			// 					if(port.property.modelProperty.locator.x==180){
			// 						sPort = port;
			// 					}
			// 				});
			// 			}
			// 			if(label=="Third1"){
			// 				$.each(ports,function(i,port){
			// 					if(port.property.modelProperty.locator.x==0){
			// 						tPort = port;
			// 						if(sPort){
			// 							activeEditor.makeConnection(sPort,tPort,connectionList[1]);
			// 						}
			// 					}
			// 				});
			// 			}
			// 		});
			// 		// 并行流程框的器件在器件展示栏中的添加
			// 		for(var cl=0;cl<componentList.length;cl++){
			// 			var className = componentList[cl].modelProperty.typeName;
			// 			var componentName = componentList[cl].modelProperty.componentName;
			// 			this.serialAddUsedPart(className,componentName);
			// 		}
			// 	}
	
				// else{
					this.createdModel = Rainier.UI.V2.DeviceModelBuilder.buildModel(ret);
					if(this.createdModel){          
					var inputs   = this.createdModel.getInputPorts();
					var outputs  = this.createdModel.getOutputPorts();
					var hybrids  = this.createdModel.getHybridPorts();
					
					inputs.each(function(i,p){
						_this.ports.add(p);
					});
					outputs.each(function(i,p){
						_this.ports.add(p);
					});
					hybrids.each(function(i,p){
						_this.ports.add(p);
					});
					}
					var start = new Date().getTime();
					thisrootEditPart.getModel().addChildModel(this.createdModel);
					var end = new Date().getTime();
					// console.log("add model cost:" + (end - start));
	
					this.createdModel.setPosition(thisx,thisy,false);

					this.addTree();
					//判断器材展示栏中是否已存在该器材，若存在则不再再次向展示栏中添加
					var className = ret.modelProperty.typeName;
					var componentName = ret.modelProperty.componentName;
					this.addUsedPart(className,componentName);
					// console.log(data);
				// }
			}
		// }
		//更新预览图
		//延迟执行
		refresh = true;
	},

	/**
	 * 函数名称：Rainier.UI.V2.CommandAdd.addUsedPart<br>
	 * 函数功能：添加树结构<br>
	 * 函数输入：className和componentName
	 * 函数返回：无<br>
	 * 异常信息：无<br>
	 */
	addTree : function(){
		//添加器件后,树结构同步
		//添加一级节点
		//控制树结构添加形式
		var model = this.createdModel;
		var prop  = model.property;
		var label = prop.modelProperty.label;
		var txt = label.replace(/-/g,'.');
		var typeName = model.property.modelProperty.typeName.substring(0,9);
		if (typeName === "TextModel"){
			//添加的节点的父节点
			var nodeParent = null;
			if(!treeControl){
				//打开实验时回显脚本的数据
				if(!openExper){
					if(model.property.modelProperty.typeName === "TextModelJson"){
						nodeParent = $("#ul-mindMap").tree('find',"firstPage");
						$("#ul-mindMap").tree('append',{
							parent : nodeParent.target,
							data : [{
								id : prop.modelProperty.id,
								text : txt + ' ' + prop.modelProperty.text,
								state : "open",
								animate : true
							}],
						});
						window.lastFNode = $("#ul-mindMap").tree('find',prop.modelProperty.id);
					}
					//添加二级节点
					else{
						//如果添加过一级节点，则新添加的二级节点是该一级节点的子节点，否则是首页的子节点
						if(model.property.modelProperty.typeName === "TextModelJson2"){
							if(window.lastFNode){
								nodeParent = window.lastFNode;
							}
							else
							{
								nodeParent = $("#ul-mindMap").tree('find',"firstPage");
							}
							$("#ul-mindMap").tree('append',{
								parent : nodeParent.target,
								data : [{
									id : prop.modelProperty.id,
									text : txt + ' ' + prop.modelProperty.text,
									state : "open",
									animate : true
								}],
							});
							window.lastSNode = $("#ul-mindMap").tree('find',prop.modelProperty.id);
						}
						//添加三级节点
						else{
							if(window.lastSNode){
								nodeParent = window.lastSNode;
							}
							else
							{
								if(window.lastFNode){
									nodeParent = window.lastFNode;
								}
								else{
									nodeParent = $("#ul-mindMap").tree('find',"firstPage");
								}
							}
							$("#ul-mindMap").tree('append',{
								parent : nodeParent.target,
								data : [{
									id : prop.modelProperty.id,
									text : txt + ' ' + prop.modelProperty.text,
									state : "open",
									animate : true
								}],
							});
						}
					}
				}
			}
		}
	},


	/**
	 * 函数名称：Rainier.UI.V2.CommandAdd.addUsedPart<br>
	 * 函数功能：(单个添加器件)判断器材展示栏中是否已存在该器材，若存在则不再再次向展示栏中添加<br>
	 * 函数输入：className和componentName
	 * 函数返回：无<br>
	 * 异常信息：无<br>
	 */
	addUsedPart : function(className,componentName){
		// if(className == "OverThreeTextModelJson" || className === "TextModelJson2" || className === "TextModelJson3"){
		// 	className = "TextModelJson";
		// }
		var usedPart = {};
		usedPart.isLogic = true;
		usedPart.courseType = "Communication";
		usedPart.deviceType = "PmsModel";
		//data_part:data的一个对象
		var data_part = {};
		data_part.className = className;
		// 还未向实验台添加器件时
		if(data.length == 0){
			if(className){
				data_part.addCount = 1;
			}
			data.push(data_part);
			usedPart.className = data[0].className;
			usedPart.componentName = componentName;
			usedPartArray.push(usedPart);
			// console.log(data);
			// console.log(usedPartArray);
		// 实验台上已经存在器件时
		}else{
			for(var i=0;i<data.length;i++){
				if(data[i].className == className){
					// console.log("已加入已使用器件数组!");
					data[i].addCount += 1;
					// console.log(data);
					return;
				}
			}
			data_part.addCount = 1;
			data.push(data_part);
			usedPart.className = data[data.length-1].className;
			usedPart.componentName = componentName;
			usedPartArray.push(usedPart);
			// console.log(data);
			// console.log(usedPartArray);
		}
		// console.log(data);
		// console.log(usedPartArray);
	},

	/**
	 * 函数名称：Rainier.UI.V2.CommandAdd.parallelAddUsedPart<br>
	 * 函数功能：(添加并行器件)判断器材展示栏中是否已存在并行模板中的器材，若存在则不再再次向展示栏中添加<br>
	 * 函数输入：className和componentName
	 * 函数返回：无<br>
	 * 异常信息：无<br>
	 */
	parallelAddUsedPart : function(className,componentName){
		var usedPart = {};
		usedPart.isLogic = true;
		usedPart.courseType = "Communication";
		usedPart.deviceType = "PmsModel"; 
		//data_part:data的一个对象
		var data_part = {};
		data_part.className = className;
		//还没有在实验台上添加器件时
		if(usedPartArray.length == 0){
			if(className){
				data_part.addCount = 1;
			}
			data.push(data_part);
			usedPart.className = data[0].className;
			usedPart.componentName = componentName;
			usedPartArray.push(usedPart);
			// console.log(usedPartArray);
			// console.log(data);
		// 已经在实验台上添加了器件
		}else{
			// 不向data中重复添加元素
			for(var i=0;i<data.length;i++){
				if(data[i].className == className){
						// console.log("data中存在"+className);
						data[i].addCount += 1;
						// console.log(data);
						return;
				}
			}
			data_part.addCount = 1;
			data.push(data_part);
			usedPart.className = data[data.length-1].className;
			usedPart.componentName = componentName;
			usedPartArray.push(usedPart);
			// console.log(usedPartArray);
			// console.log(data);
		}
		// console.log(data);
	},

	/**
	 * 函数名称：Rainier.UI.V2.CommandAdd.serialAddUsedPart<br>
	 * 函数功能：(添加串行器件)判断器材展示栏中是否已存在串行模板中的器材，若存在则不再再次向展示栏中添加<br>
	 * 函数输入：className和componentName
	 * 函数返回：无<br>
	 * 异常信息：无<br>
	 */
	serialAddUsedPart : function(className,componentName){
		var usedPart = {};
		usedPart.isLogic = true;
		usedPart.courseType = "Communication";
		usedPart.deviceType = "PmsModel"; 
		//data_part:data的一个对象
		var data_part = {};
		data_part.className = className;
		//还没有在实验台上添加器件时
		if(usedPartArray.length == 0){
			if(className){
				data_part.addCount = 1;
			}
			data.push(data_part);
			usedPart.className = data[0].className;
			usedPart.componentName = componentName;
			usedPartArray.push(usedPart);
			// console.log(usedPartArray);
			// console.log(data);
		// 已经在实验台上添加了器件
		}else{
			// 不向data中重复添加元素
			for(var i=0;i<data.length;i++){
				if(data[i].className == className){
						// console.log("data中存在"+className);
						data[i].addCount += 1;
						return;
				}
			}
			data_part.addCount = 1;
			data.push(data_part);
			usedPart.className = data[data.length-1].className;
			usedPart.componentName = componentName;
			usedPartArray.push(usedPart);
			// console.log(usedPartArray);
			// console.log(data);
		}
		// console.log(usedPartArray);
		// console.log(data);
	},

	/**
	 * 函数名称：Rainier.UI.V2.CommandAdd.undo<br>
	 * 函数功能：取消操作命令(撤销)<br>
	 * 函数返回：无<br>
	 * 异常信息：无<br>
	 */
	undo:function(){
		if(this.createdModel != null){

			// 删除已使用器材
			var className = this.createdModel.property.modelProperty.typeName;
			this.deleteUsedPart(className);
			
			thisrootEditPart.getModel().removeChildModel(this.createdModel);
			var model = this.createdModel;
			//同步删除树结构
			var id = model.property.modelProperty.id;
			var node = $("#ul-mindMap").tree('find',id);
			if(node){
				$("#ul-mindMap").tree('remove',node.target);
			}
			//父节点删除子信息
			var parent =  model.property.modelProperty.parent;
			if(parent){
				var children = parent.modelProperty.children;
				for(var i=0;i<children.length;i++){
					var _id = children[i];
					if(_id==id){
						var index = children.indexOf(_id);
						children.splice(index,1);
					}
				}
			}
		}else{
			for(var j=0;j<this.createdModelArray.length;j++){
				var className = this.createdModelArray[j].property.modelProperty.typeName;
				for(var i=0;i<data.length;i++){
					if(data[i].className == className){
						data[i].addCount -= 1;
					}
					if(data[i].addCount <= 0){
						data.splice(i, 1);
					}
				}
				// console.log(data);
				thisrootEditPart.getModel().removeChildModel(this.createdModelArray[j]);
			}
		}
		// console.log(data);
	},

	/**
	 * 函数名称：Rainier.UI.V2.CommandMove.redo<br>
	 * 函数功能：重做命令(恢复)<br>
	 * 函数返回：无<br>
	 * 异常信息：无<br>
	 */
	redo:function(){
		if(this.createdModel){
			this.ports.each($.proxy(function(j,c){
				this.createdModel.addPort(c);
			},this));
			thisrootEditPart.getModel().addChildModel(this.createdModel);
			this.createdModel.setPosition(this.x,this.y,false);
			this.addTree();
			var className = this.createdModel.property.modelProperty.typeName;
			var componentName = this.createdModel.property.modelProperty.componentName;
			this.addUsedPart(className,componentName);	
		}else{
			// for(var d=0;d<this.createdModelArray.length;d++){
			// 	// for(var p=0;p<this.portsArray.length;p++){
			// 		// console.log(this.portsArray[p]);
			// 		this.ports.each($.proxy(function(j,c){
			// 			this.createdModelArray[d].addPort(c);
			// 		},this));
			// 	// }
			// 	var className = this.createdModelArray[d].property.modelProperty.typeName;
			// 	for(var i=0;i<data.length;i++){
			// 		if(data[i].className == className){
			// 			data[i].addCount += 1;
			// 		}
			// 	}
			// 	thisrootEditPart.getModel().addChildModel(this.createdModelArray[d]);
			// 	this.createdModelArray[d].setPosition(thisx,thisy,false);  
			// }
			this.execute();
		}
	},

	/**
	 * 函数名称：Rainier.UI.V2.CommandAdd.deleteUsedPart<br>
	 * 函数功能：根据addCount的值删除器件展示栏中的器件，若为0，则删除<br>
	 * 函数返回：无<br>
	 * 异常信息：无<br>
	 */
	deleteUsedPart : function(className){
		if(className){
			// if(className == "OverThreeTextModelJson" || className === "TextModelJson2" || className === "TextModelJson3"){
			// 	className = "TextModelJson";
			// }
			for(var i=0;i<data.length;i++){
				if(className == data[i].className){
					data[i].addCount -=1;
					if(data[i].addCount > 0){
						// console.log(data);
						// console.log(usedPartArray);
						// console.log("实验台上还存在"+className);
						return;
					}else{
						data.splice(i, 1);
						// console.log(data);
						// addCount<=0且usedPartArray中存在该className对应的器件信息时，将该器件从器件展示栏删除
						for(var j=0;j<usedPartArray.length;j++){
							if(usedPartArray[j].className == className){
								usedPartArray.splice(j, 1);
								// console.log(usedPartArray);
							}
						}
					}
				}
			}
		}
	},
});
thisrootEditPart = null;
thisx = null;
thisy = null;